package com.javase.base.syntax;

/**
 * @author zq
 * @Date: 2020/5/27
 * 多维数据理解：多维数据其实就是数组嵌套数据组
 * 稀疏数组：
 */
public class ArrayDemo1 {

    public static void main(String[] args) {

        ArrayDemo1 arrayDemo1 = new ArrayDemo1();
        sparseArray();
    }

    /**
     * 多维数组学习
     */
    public static void ArrayMany(){

        //定义一个多维数组
        int[][] array = {{1, 2, 3}, {2, 3, 4}, {3, 4, 5}, {4, 5, 6}};

        //遍历这个多维数据
        for (int i = 0; i < array.length; i++) { //循环遍历数组第一层
            for (int j = 0; j < array[i].length; j++) {
                System.out.println(array[i][j]);
            }
            System.out.println("==================================");
        }
    }

    /**
     * 稀疏数组
     *
     * 原数组
     * 0	0	0	22	0	0	15
     * 0	11	0	0	0	17	0
     * 0	0	0	-6	0	0	0
     * 0	0	0	0	0	39	0
     * 91	0	0	0	0	0	0
     * 0	0	28	0	0	0	0
     *
     *
     *上面的数组大部分数据为0，通过稀疏数组把有效的数组保存
     * 稀疏数组（压缩算法）
     * 稀疏数组的处理方式：
     * 1.记录数组中几行几列，有多少个有效的值
     * 2.记录每个有效值得坐标，从而缩小程序的规模
     *
     * 6	7	8
     * 0	3	22
     * 0	6	15
     * 1	1	11
     * 1	5	17
     * 2	3	-6
     * 3	5	39
     * 4	0	91
     * 5	2	28
     */
    public static void sparseArray(){

        //定义一个6行7列的数组
        int[][] arr = new int[6][7];
        arr[0][3] = 22;
        arr[0][6] = 15;
        arr[1][1] = 11;
        arr[1][5] = 17;
        arr[2][3] = -6;
        arr[3][5] = 39;
        arr[4][0] = 91;
        arr[5][2] = 28;

        //输出原始数组
        System.out.println("================打印原始数组=============");
        for (int[] ints : arr) {
            for (int anInt : ints) {
                System.out.print(anInt+"\t");
            }
            System.out.println();
        }

        //转换成稀疏数组
        //获取有效值的个数
        int sum = 0;
        for (int[] ints : arr) {
            for (int anInt : ints) {
                if (anInt != 0 ){
                    sum++;
                }
            }
        }
        
        //定义一个有效值+1行 3列的一个多维数组
        int[][] array = new int[sum+1][3];
        //第一行赋值为几行几列几个有效值
        array[0][0] = arr.length;
        array[0][1] = arr[0].length;
        array[0][2] = sum;

        //添加有效值的坐标及对应值
        int count = 1;
        for (int i = 0; i < arr.length; i++) {
            for (int i1 = 0; i1 < arr[i].length; i1++) {
                if(arr[i][i1] != 0 ){
                    array[count][0] = i;  //横坐标
                    array[count][1] = i1; //纵坐标
                    array[count][2] = arr[i][i1]; //值
                    count++;
                }
            }
        }

        //打印稀疏数组
        System.out.println("================打印稀疏数组=============");
        for (int[] ints : array) {
            for (int anInt : ints) {
                System.out.print(anInt+"\t");
            }
            System.out.println();
        }

        //还原稀疏数组
        //定义一个二维数组
        int[][] reduction = new int[array[0][0]][array[0][1]];

        for (int i = 1; i < array.length; i++) {
            reduction[array[i][0]][array[i][1]] = array[i][2];
        }

        System.out.println("================还原稀疏数组=============");
        for (int[] ints : reduction) {
            for (int anInt : ints) {
                System.out.print(anInt+"\t");
            }
            System.out.println();
        }

    }
}
